home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / lisp / wgdb-42.lha / wgdb-4.2 / gdb / core.c < prev    next >
C/C++ Source or Header  |  1992-09-11  |  12KB  |  462 lines
  1. /* Work with core dump and executable files, for GDB.
  2.    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include <stdio.h>
  21. #include <errno.h>
  22. #include <signal.h>
  23. #include <fcntl.h>
  24. #include "defs.h"
  25. #include "param.h"
  26. #include "frame.h"  /* required by inferior.h */
  27. #include "inferior.h"
  28. #include "symtab.h"
  29. #include "command.h"
  30. #include "bfd.h"
  31. #include "target.h"
  32. #include "gdbcore.h"
  33.  
  34. extern int xfer_memory ();
  35. extern void child_attach (), child_create_inferior ();
  36.  
  37. extern int sys_nerr;
  38. extern char *sys_errlist[];
  39. extern char *sys_siglist[];
  40.  
  41. extern char registers[];
  42.  
  43. /* Hook for `exec_file_command' command to call.  */
  44.  
  45. void (*exec_file_display_hook) () = NULL;
  46.  
  47. /* Binary file diddling handle for the core file.  */
  48.  
  49. bfd *core_bfd = NULL;
  50.  
  51. /* Forward decl */
  52. extern struct target_ops core_ops;
  53.  
  54.  
  55. /* Discard all vestiges of any previous core file
  56.    and mark data and stack spaces as empty.  */
  57.  
  58. /* ARGSUSED */
  59. void
  60. core_close (quitting)
  61.      int quitting;
  62. {
  63.   if (core_bfd) {
  64.     free (bfd_get_filename (core_bfd));
  65.     bfd_close (core_bfd);
  66.     core_bfd = NULL;
  67. #ifdef CLEAR_SOLIB
  68.     CLEAR_SOLIB ();
  69. #endif
  70.     if (core_ops.sections) {
  71.       free (core_ops.sections);
  72.       core_ops.sections = NULL;
  73.       core_ops.sections_end = NULL;
  74.     }
  75.   }
  76. }
  77.  
  78. #ifdef SOLIB_ADD
  79. /* Stub function for catch_errors around shared library hacking. */
  80.  
  81. int 
  82. solib_add_stub (from_tty)
  83.      char *from_tty;
  84. {
  85.     SOLIB_ADD (NULL, (int)from_tty, &core_ops);
  86.     return 0;
  87. }
  88. #endif /* SOLIB_ADD */
  89.  
  90. /* This routine opens and sets up the core file bfd */
  91.  
  92. void
  93. core_open (filename, from_tty)
  94.      char *filename;
  95.      int from_tty;
  96. {
  97.   const char *p;
  98.   int siggy;
  99.   struct cleanup *old_chain;
  100.   char *temp;
  101.   bfd *temp_bfd;
  102.   int ontop;
  103.   int scratch_chan;
  104.  
  105.   target_preopen (from_tty);
  106.   if (!filename)
  107.     {
  108.       error (core_bfd? 
  109.        "No core file specified.  (Use `detach' to stop debugging a core file.)"
  110.      : "No core file specified.");
  111.     }
  112.  
  113.   filename = tilde_expand (filename);
  114.   if (filename[0] != '/') {
  115.     temp = concat (current_directory, "/", filename);
  116.     free (filename);
  117.     filename = temp;
  118.   }
  119.  
  120.   old_chain = make_cleanup (free, filename);
  121.  
  122.   scratch_chan = open (filename, write_files? O_RDWR: O_RDONLY, 0);
  123.   if (scratch_chan < 0)
  124.     perror_with_name (filename);
  125.  
  126.   temp_bfd = bfd_fdopenr (filename, NULL, scratch_chan);
  127.   if (temp_bfd == NULL)
  128.     {
  129.       perror_with_name (filename);
  130.     }
  131.  
  132.   if (!bfd_check_format (temp_bfd, bfd_core))
  133.     {
  134.       make_cleanup (bfd_close, temp_bfd);    /* Do it after the err msg */
  135.       error ("\"%s\" is not a core dump: %s", filename, bfd_errmsg(bfd_error));
  136.     }
  137.  
  138.   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
  139.  
  140.   discard_cleanups (old_chain);        /* Don't free filename any more */
  141.   unpush_target (&core_ops);
  142.   core_bfd = temp_bfd;
  143.   old_chain = make_cleanup (core_close, core_bfd);
  144.  
  145.   validate_files ();
  146.  
  147.   /* Find the data section */
  148.   if (build_section_table (core_bfd, &core_ops.sections,
  149.                &core_ops.sections_end))
  150.     error ("Can't find sections in `%s': %s", bfd_get_filename(core_bfd),
  151.        bfd_errmsg (bfd_error));
  152.  
  153.   ontop = !push_target (&core_ops);
  154.   discard_cleanups (old_chain);
  155.  
  156.   p = bfd_core_file_failing_command (core_bfd);
  157.   if (p)
  158.     printf ("Core file invoked as `%s'.\n", p);
  159.  
  160.   siggy = bfd_core_file_failing_signal (core_bfd);
  161.   if (siggy > 0)
  162.     printf ("Program terminated with signal %d, %s.\n", siggy,
  163.         siggy < NSIG ? sys_siglist[siggy] : "(undocumented)");
  164.  
  165.   if (ontop) {
  166.     /* Fetch all registers from core file */
  167.     target_fetch_registers (-1);
  168.  
  169.     /* Add symbols and section mappings for any shared libraries */
  170. #ifdef SOLIB_ADD
  171.     (void) catch_errors (solib_add_stub, (char *)from_tty, (char *)0);
  172. #endif
  173.  
  174.     /* Now, set up the frame cache, and print the top of stack */
  175.     set_current_frame (create_new_frame (read_register (FP_REGNUM),
  176.                      read_pc ()));
  177.     select_frame (get_current_frame (), 0);
  178.     print_stack_frame (selected_frame, selected_frame_level, 1);
  179.   } else {
  180.     printf (
  181. "Warning: you won't be able to access this core file until you terminate\n\
  182. your %s; do ``info files''\n", current_target->to_longname);
  183.   }
  184. }
  185.  
  186. void
  187. core_detach (args, from_tty)
  188.      char *args;
  189.      int from_tty;
  190. {
  191.   if (args)
  192.     error ("Too many arguments");
  193.   unpush_target (&core_ops);
  194.   if (from_tty)
  195.     printf ("No core file now.\n");
  196. }
  197.  
  198. /* Backward compatability with old way of specifying core files.  */
  199.  
  200. void
  201. core_file_command (filename, from_tty)
  202.      char *filename;
  203.      int from_tty;
  204. {
  205.   dont_repeat ();            /* Either way, seems bogus. */
  206.   if (!filename)
  207.     core_detach (filename, from_tty);
  208.   else
  209.     core_open (filename, from_tty);
  210. }
  211.  
  212.  
  213. /* Call this to specify the hook for exec_file_command to call back.
  214.    This is called from the x-window display code.  */
  215.  
  216. void
  217. specify_exec_file_hook (hook)
  218.      void (*hook) ();
  219. {
  220.   exec_file_display_hook = hook;
  221. }
  222.  
  223. /* The exec file must be closed before running an inferior.
  224.    If it is needed again after the inferior dies, it must
  225.    be reopened.  */
  226.  
  227. void
  228. close_exec_file ()
  229. {
  230. #ifdef FIXME
  231.   if (exec_bfd)
  232.     bfd_tempclose (exec_bfd);
  233. #endif
  234. }
  235.  
  236. void
  237. reopen_exec_file ()
  238. {
  239. #ifdef FIXME
  240.   if (exec_bfd)
  241.     bfd_reopen (exec_bfd);
  242. #endif
  243. }
  244.  
  245. /* If we have both a core file and an exec file,
  246.    print a warning if they don't go together.  */
  247.  
  248. void
  249. validate_files ()
  250. {
  251.   if (exec_bfd && core_bfd)
  252.     {
  253.       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
  254.     printf ("Warning: core file may not match specified executable file.\n");
  255.       else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
  256.     printf ("Warning: exec file is newer than core file.\n");
  257.     }
  258. }
  259.  
  260. /* Return the name of the executable file as a string.
  261.    ERR nonzero means get error if there is none specified;
  262.    otherwise return 0 in that case.  */
  263.  
  264. char *
  265. get_exec_file (err)
  266.      int err;
  267. {
  268.   if (exec_bfd) return bfd_get_filename(exec_bfd);
  269.   if (!err)     return NULL;
  270.  
  271.   error ("No executable file specified.\n\
  272. Use the \"file\" or \"exec-file\" command.");
  273.   return NULL;
  274. }
  275.  
  276. static void
  277. core_files_info (t)
  278.   struct target_ops *t;
  279. {
  280.   struct section_table *p;
  281.  
  282.   printf ("\tCore file `%s'.\n", bfd_get_filename(core_bfd));
  283.  
  284.   for (p = t->sections; p < t->sections_end; p++) {
  285.     printf("\t%s", local_hex_string_custom (p->addr, "08"));
  286.     printf(" - %s is %s", local_hex_string_custom (p->endaddr, "08"),
  287.        bfd_section_name (p->bfd, p->sec_ptr));
  288.     if (p->bfd != core_bfd) {
  289.       printf(" in %s", bfd_get_filename (p->bfd));
  290.     }
  291.     printf ("\n");
  292.   }
  293. }
  294.  
  295. void
  296. memory_error (status, memaddr)
  297.      int status;
  298.      CORE_ADDR memaddr;
  299. {
  300.  
  301.   if (status == EIO)
  302.     {
  303.       /* Actually, address between memaddr and memaddr + len
  304.      was out of bounds. */
  305.       error ("Cannot access memory at address %s.", local_hex_string(memaddr));
  306.     }
  307.   else
  308.     {
  309.       if (status >= sys_nerr || status < 0)
  310.     error ("Error accessing memory address %s: unknown error (%d).",
  311.            local_hex_string(memaddr), status);
  312.       else
  313.     error ("Error accessing memory address %s: %s.",
  314.            local_hex_string(memaddr), sys_errlist[status]);
  315.     }
  316. }
  317.  
  318. /* Same as target_read_memory, but report an error if can't read.  */
  319. void
  320. read_memory (memaddr, myaddr, len)
  321.      CORE_ADDR memaddr;
  322.      char *myaddr;
  323.      int len;
  324. {
  325.   int status;
  326.   status = target_read_memory (memaddr, myaddr, len);
  327.   if (status != 0)
  328.     memory_error (status, memaddr);
  329. }
  330.  
  331. /* Same as target_write_memory, but report an error if can't write.  */
  332. void
  333. write_memory (memaddr, myaddr, len)
  334.      CORE_ADDR memaddr;
  335.      char *myaddr;
  336.      int len;
  337. {
  338.   int status;
  339.  
  340.   status = target_write_memory (memaddr, myaddr, len);
  341.   if (status != 0)
  342.     memory_error (status, memaddr);
  343. }
  344.  
  345. /* Read an integer from debugged memory, given address and number of bytes.  */
  346.  
  347. long
  348. read_memory_integer (memaddr, len)
  349.      CORE_ADDR memaddr;
  350.      int len;
  351. {
  352.   char cbuf;
  353.   short sbuf;
  354.   int ibuf;
  355.   long lbuf;
  356.  
  357.   if (len == sizeof (char))
  358.     {
  359.       read_memory (memaddr, &cbuf, len);
  360.       return cbuf;
  361.     }
  362.   if (len == sizeof (short))
  363.     {
  364.       read_memory (memaddr, (char *)&sbuf, len);
  365.       SWAP_TARGET_AND_HOST (&sbuf, sizeof (short));
  366.       return sbuf;
  367.     }
  368.   if (len == sizeof (int))
  369.     {
  370.       read_memory (memaddr, (char *)&ibuf, len);
  371.       SWAP_TARGET_AND_HOST (&ibuf, sizeof (int));
  372.       return ibuf;
  373.     }
  374.   if (len == sizeof (lbuf))
  375.     {
  376.       read_memory (memaddr, (char *)&lbuf, len);
  377.       SWAP_TARGET_AND_HOST (&lbuf, sizeof (lbuf));
  378.       return lbuf;
  379.     }
  380.   error ("Cannot handle integers of %d bytes.", len);
  381.   return -1;    /* for lint */
  382. }
  383.  
  384. /* Get the registers out of a core file.  This is the machine-
  385.    independent part.  Fetch_core_registers is the machine-dependent
  386.    part, typically implemented in the xm-file for each architecture.  */
  387.  
  388. /* We just get all the registers, so we don't use regno.  */
  389. /* ARGSUSED */
  390. static void
  391. get_core_registers (regno)
  392.      int regno;
  393. {
  394.   sec_ptr reg_sec;
  395.   unsigned size;
  396.   char *the_regs;
  397.  
  398.   reg_sec = bfd_get_section_by_name (core_bfd, ".reg");
  399.   if (!reg_sec) goto cant;
  400.   size = bfd_section_size (core_bfd, reg_sec);
  401.   the_regs = alloca (size);
  402.   if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size))
  403.     {
  404.       fetch_core_registers (the_regs, size, 0,
  405.                 (unsigned) bfd_section_vma (abfd,reg_sec));
  406.     }
  407.   else
  408.     {
  409. cant:
  410.       fprintf (stderr, "Couldn't fetch registers from core file: %s\n",
  411.            bfd_errmsg (bfd_error));
  412.     }
  413.  
  414.   /* Now do it again for the float registers, if they exist.  */
  415.   reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
  416.   if (reg_sec) {
  417.     size = bfd_section_size (core_bfd, reg_sec);
  418.     the_regs = alloca (size);
  419.     if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0,
  420.                   size))
  421.       {
  422.     fetch_core_registers (the_regs, size, 2,
  423.                   (unsigned) bfd_section_vma (abfd,reg_sec));
  424.       }
  425.     else
  426.       {
  427.     fprintf (stderr, "Couldn't fetch register set 2 from core file: %s\n",
  428.          bfd_errmsg (bfd_error));
  429.       }
  430.   }
  431.   registers_fetched();
  432. }
  433.  
  434. struct target_ops core_ops = {
  435.     "core", "Local core dump file",
  436.     "Use a core file as a target.  Specify the filename of the core file.",
  437.     core_open, core_close,
  438.     child_attach, core_detach, 0, 0, /* resume, wait */
  439.     get_core_registers, 
  440.     0, 0, 0, 0, /* store_regs, prepare_to_store, conv_to, conv_from */
  441.     xfer_memory, core_files_info,
  442.     0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */
  443.     0, 0, 0, 0, 0, /* terminal stuff */
  444.     0, 0, 0, 0, /* kill, load, call fn, lookup sym */
  445.     child_create_inferior, 0, /* mourn_inferior */
  446.     core_stratum, 0, /* next */
  447.     0, 1, 1, 1, 0,    /* all mem, mem, stack, regs, exec */
  448.     0, 0,            /* section pointers */
  449.     OPS_MAGIC,        /* Always the last thing */
  450. };
  451.  
  452. void
  453. _initialize_core()
  454. {
  455.  
  456.   add_com ("core-file", class_files, core_file_command,
  457.        "Use FILE as core dump for examining memory and registers.\n\
  458. No arg means have no core file.  This command has been superseded by the\n\
  459. `target core' and `detach' commands.");
  460.   add_target (&core_ops);
  461. }
  462.